package com.cnap.multiclouldmgmt.model.k8sMonitorModels;

import com.cnap.multiclouldmgmt.model.K8sClusterInfoModel;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
/**
 * 监控或者算法需要的数据
 * @author dyq
 */
@ApiModel(value = "com.cnap.multiclouldmgmt.model.k8sMonitorModels.PodAlgInfoModel",description = "算法所需要的副本的参数")
public class PodAlgInfoModel extends K8sClusterInfoModel {

    //工作负载名称
    @ApiModelProperty(value = "工作负载名称")
    private String workLoadName;

    //命名空间
    @ApiModelProperty(value = "命名空间 ")
    private String namespace;

    //cpu总量，核数，
    @ApiModelProperty(value = "cpu总量，核数，")
    private double cpuNum;

    //cpu总量，核数单位n，
    @ApiModelProperty(value = "cpu总量，核数单位n")
    private long cpuNumByN;

    //cpu使用量，核数，
    @ApiModelProperty(value = "cpu使用量，核数，")
    private double cpuUseNum;

    //cpu总量，核数单位n，
    @ApiModelProperty(value = "cpu使用量，核数单位n")
    private long cpuUseNumByN;

    //内存总量，单位mb，
    @ApiModelProperty(value = "内存总量，单位mb")
    private int memQuato;

    //内存使用量，单位mb，
    @ApiModelProperty(value = "内存使用量量，单位mb")
    private int memUse;

    //磁盘的总读写速率
    @ApiModelProperty(value = "磁盘的总读写速率，单位MB/s")
    private int diskThroughput;

    //该节点当前占用读写速率
    @ApiModelProperty(value = "该节点当前占用读写速率，单位MB/s")
    private int diskCurrentThroughput;

    //该节点磁盘秒均总读写次数，单位次/s
    @ApiModelProperty(value = "该节点磁盘秒均总读写次数，单位次/s")
    private int diskIpos;

    //该节点当前占用读写次数，单位次/s
    @ApiModelProperty(value = "该节点当前占用读写次数，单位次/s")
    private int diskCurrentIpos;

    //该节点网络总带宽，单位bps
    @ApiModelProperty(value = "该节点网络总带宽，单位bps")
    private int netBandwidth;

    //该节点当前占用带宽，单位bps
    @ApiModelProperty(value = "该节点当前占用带宽，单位bps")
    private int netCurrentBandwidth;

    /**
     * get
     *
     * @return WorkLoadName
     */
    public String getWorkLoadName() {
        return workLoadName;
    }

    /**
     * set
     *
     * @param workLoadName workLoadName
     */
    public void setWorkLoadName(String workLoadName) {
        this.workLoadName = workLoadName;
    }

    /**
     * get
     *
     * @return Namespace
     */
    public String getNamespace() {
        return namespace;
    }

    /**
     * set
     *
     * @param namespace namespace
     */
    public void setNamespace(String namespace) {
        this.namespace = namespace;
    }

    /**
     * get
     *
     * @return CpuNum
     */
    public double getCpuNum() {
        return cpuNum;
    }

    /**
     * set
     *
     * @param cpuNum cpuNum
     */
    public void setCpuNum(double cpuNum) {
        this.cpuNum = cpuNum;
    }

    /**
     * get
     *
     * @return CpuNumByN
     */
    public long getCpuNumByN() {
        return cpuNumByN;
    }

    /**
     * set
     *
     * @param cpuNumByN cpuNumByN
     */
    public void setCpuNumByN(long cpuNumByN) {
        this.cpuNumByN = cpuNumByN;
    }

    /**
     * get
     *
     * @return CpuUseNum
     */
    public double getCpuUseNum() {
        return cpuUseNum;
    }

    /**
     * set
     *
     * @param cpuUseNum cpuUseNum
     */
    public void setCpuUseNum(double cpuUseNum) {
        this.cpuUseNum = cpuUseNum;
    }

    /**
     * get
     *
     * @return CpuUseNumByN
     */
    public long getCpuUseNumByN() {
        return cpuUseNumByN;
    }

    /**
     * set
     *
     * @param cpuUseNumByN cpuUseNumByN
     */
    public void setCpuUseNumByN(long cpuUseNumByN) {
        this.cpuUseNumByN = cpuUseNumByN;
    }

    /**
     * get
     *
     * @return MemQuato
     */
    public int getMemQuato() {
        return memQuato;
    }

    /**
     * set
     *
     * @param memQuato memQuato
     */
    public void setMemQuato(int memQuato) {
        this.memQuato = memQuato;
    }

    /**
     * get
     *
     * @return MemUse
     */
    public int getMemUse() {
        return memUse;
    }

    /**
     * set
     *
     * @param memUse memUse
     */
    public void setMemUse(int memUse) {
        this.memUse = memUse;
    }

    /**
     * get
     *
     * @return DiskThroughput
     */
    public int getDiskThroughput() {
        return diskThroughput;
    }

    /**
     * set
     *
     * @param diskThroughput diskThroughput
     */
    public void setDiskThroughput(int diskThroughput) {
        this.diskThroughput = diskThroughput;
    }

    /**
     * get
     *
     * @return DiskCurrentThroughput
     */
    public int getDiskCurrentThroughput() {
        return diskCurrentThroughput;
    }

    /**
     * set
     *
     * @param diskCurrentThroughput diskCurrentThroughput
     */
    public void setDiskCurrentThroughput(int diskCurrentThroughput) {
        this.diskCurrentThroughput = diskCurrentThroughput;
    }

    /**
     * get
     *
     * @return DiskIpos
     */
    public int getDiskIpos() {
        return diskIpos;
    }

    /**
     * set
     *
     * @param diskIpos diskIpos
     */
    public void setDiskIpos(int diskIpos) {
        this.diskIpos = diskIpos;
    }

    /**
     * get
     *
     * @return DiskCurrentIpos
     */
    public int getDiskCurrentIpos() {
        return diskCurrentIpos;
    }

    /**
     * set
     *
     * @param diskCurrentIpos diskCurrentIpos
     */
    public void setDiskCurrentIpos(int diskCurrentIpos) {
        this.diskCurrentIpos = diskCurrentIpos;
    }

    /**
     * get
     *
     * @return NetBandwidth
     */
    public int getNetBandwidth() {
        return netBandwidth;
    }

    /**
     * set
     *
     * @param netBandwidth netBandwidth
     */
    public void setNetBandwidth(int netBandwidth) {
        this.netBandwidth = netBandwidth;
    }

    /**
     * get
     *
     * @return NetCurrentBandwidth
     */
    public int getNetCurrentBandwidth() {
        return netCurrentBandwidth;
    }

    /**
     * set
     *
     * @param netCurrentBandwidth netCurrentBandwidth
     */
    public void setNetCurrentBandwidth(int netCurrentBandwidth) {
        this.netCurrentBandwidth = netCurrentBandwidth;
    }
}
